We have shown that modelling hardware in Haskell can easily be done using abstract 
data types and monads. Representation of the CPU and its instructions felt very natural 
and was modelled intuitively when abstracting low-level instructions to Haskell functions.
The PPU on the other hand, was not modelled in the same clean fashion, since it
involves a lot more low-level operations.  

Communication between the CPU and the PPU was solved in a clean and pure fashion
using the \textit{enterprise pulling} technique. The code became very modular, thus 
changing the internal representation of the CPU with the underlying data 
structures does not entail major changes to the core implementation.

Running only the CPU in a strict setting was fast and efficient. When adding 
the PPU and the communication between the two units, the need for laziness arised in our
implementation. This made the program execute slower, which we suspect is due 
to the program thunking a lot of data which could be solved with various strictness 
annotations and optimizations. This has been partially solved by running everything 
but the communication strict. However, many more optimizations could have been 
done, but it was not prioritized, mostly due to lack of time.
